/**
 * @content 数据库对象功能组件
 * @author  2019-09-18
 */
import { NativeModules } from 'react-native';

let DB = NativeModules.JSDataBase;

import FClsInfo from './FClsInfo.js';
import AnnClsInfo from './AnnClsInfo.js';

/**
 * @class DataBase
 * @description 数据库对象
 */
export default class DataBase {
  /**
   * 构造一个新的 DataBase 对象。
   * @memberOf DataBase
   * @returns {Promise.<DataBase>}数据库对象
   */
  async createObj() {
    try {
      var { DataBaseId } = await DB.createObj();
      var db = new DataBase();
      db._MGDataBaseId = DataBaseId;
      return db;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取数据库名称
   * @memberOf DataBase
   * @return {Promise}数据库名称
   */
  async getName() {
    try {
      return await DB.getName(this._MGDataBaseId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取数据库全路径
   * @memberOf DataBase
   * @return {Promise}数据库名称
   */
  async getFullName() {
    try {
      return await DB.getFullName(this._MGDataBaseId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 返回数据库的打开标志
   * @memberOf DataBase
   * @return {Promise} 是否打开
   */
  async hasOpened() {
    try {
      return await DB.hasOpened(this._MGDataBaseId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 创建数据库
   * @memberOf DataBase
   * @param strDatabasePath 数据库文件路径
   * @return  {Promise} 成功：>0;失败：<=0
   */
  async create(strDatabasePath) {
    try {
      return await DB.create(this._MGDataBaseId, strDatabasePath);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 关闭数据库
   * @memberOf DataBase
   * @return {Promise} 成功：>0;失败：<=0
   */
  async close() {
    try {
      return await DB.close(this._MGDataBaseId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取数据库内指定类类型的所有类ID
   * @memberOf DataBase
   * @param type 类类型
   * @param dsID 要素集ID
   * @return {Promise<Array>} 所有类ID
   */
  async getXclseIDs(type, dsID) {
    try {
      let clsIDArray = await DB.getXclseIDs(this._MGDataBaseId, type, dsID);
      return clsIDArray;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取类信息
   * @memberOf DataBase
   * @param type 类类型
   * @param clsID 类ID
   * @return {Promise<XClsInfo>} 类信息
   */
  async getXclsInfo(type, clsID) {
    try {
      let xClsInfo;
      var { XClsInfoId, XClsInfoType } = await DB.getXclsInfo(
        this._MGDataBaseId,
        type,
        clsID
      ); // 获取到要素类信息id，要素类类型
      switch (XClsInfoType) {
        case 1: // 矢量图层
          xClsInfo = new FClsInfo();
          xClsInfo._MGXClsInfoId = XClsInfoId;
          break;
        case 2: // 组图层
          xClsInfo = new AnnClsInfo();
          xClsInfo._MGXClsInfoId = XClsInfoId;
          break;
        default:
          break;
      }
      return xClsInfo;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取类名称
   * @memberOf DataBase
   * @param type 类类型
   * @param xclsID 类ID
   * @return {Promise} 类名称
   */
  async getXclsName(type, xclsID) {
    try {
      return await DB.getXclsName(this._MGDataBaseId, type, xclsID);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取指定类类型的类的数目
   * @memberOf DataBase
   * @param type 类类型
   * @return {Promise} 类的数目
   */
  async getXclsNum(type, dsID) {
    try {
      return await DB.getXclsNum(this._MGDataBaseId, type, dsID);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 打开数据库
   * @memberOf DataBase
   * @param 数据库文件路径
   * @return {Promise} 成功：>0;失败：<=0
   */
  async open(strDatabasePath) {
    try {
      return await DB.open(this._MGDataBaseId, strDatabasePath);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 查看指定类类型和类名称的类在数据库中是否存在,如果存在,返回其ID
   * @memberOf DataBase
   * @param {number} type 类类型
   * @param {String} name 类名称
   * @return {Promise} 成功：类ID;失败：<=0
   */
  async xClsIsExist(type, name) {
    try {
      return await DB.xClsIsExist(this._MGDataBaseId, type, name);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 导入更新包进行数据更新(目前仅支持桌面编辑后的全量图层更新)
   * @memberOf DataBase
   * @param strUpdateDatabasePath 更新包全路径
   * @param name 类名称
   * @return {Promise<void>}
   */
  async updateAsync(strUpdateDatabasePath) {
    try {
      await DB.updateAsync(this._MGDataBaseId, strUpdateDatabasePath);
    } catch (e) {
      console.error(e);
    }
  }
}
